In [1]:
import numpy as np
import cv2
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
i=2
image_name='calibration'+str(i)
existing_folder_name='camera_cal/'
New_foler_name='output_images/'
fname = existing_folder_name+image_name+".jpg"
img = cv2.imread(fname)
objpoints=[]
imgpoints=[]
objp=np.zeros((6*9,3), np.float32)
objp[:,:2]=np.mgrid[0:9,0:6].T.reshape(-1,2)
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ret, corners = cv2.findChessboardCorners(gray,(9,6),None)
#if ret == True:
imgpoints.append(corners)
objpoints.append(objp)
img=cv2.drawChessboardCorners(img, (9, 6), corners, ret)
ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None)
dst = cv2.undistort(img, mtx, dist, None, mtx)
plt.imshow(dst)
plt.show()
for i in range(1,20):
image_name='calibration'+str(i)
existing_folder_name='camera_cal/'
New_foler_name='output_images/'
fname = existing_folder_name+image_name+".jpg"
img = cv2.imread(fname)
dst = cv2.undistort(img, mtx, dist, None, mtx)
plt.imshow(dst)
plt.show()
cv2.imwrite(New_foler_name+image_name+"_result.jpg", dst)
In [2]:
import numpy as np
import cv2
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
i=2
image_name='calibration'+str(i)
existing_folder_name='camera_cal/'
New_foler_name='output_images/'
fname = existing_folder_name+image_name+".jpg"
img = cv2.imread(fname)
objpoints=[]
imgpoints=[]
objp=np.zeros((6*9,3), np.float32)
objp[:,:2]=np.mgrid[0:9,0:6].T.reshape(-1,2)
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ret, corners = cv2.findChessboardCorners(gray,(9,6),None)
#if ret == True:
imgpoints.append(corners)
objpoints.append(objp)
img=cv2.drawChessboardCorners(img, (9, 6), corners, ret)
ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None)
dst = cv2.undistort(img, mtx, dist, None, mtx)
plt.imshow(dst)
plt.show()
#cv2.imwrite(New_foler_name+image_name+"_result.jpg", dst)
fname = 'test6.jpg'
img = cv2.imread(fname)
img=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
img=cv2.undistort(img, mtx, dist, None, mtx)
plt.imshow(img)
plt.show()
orignal_img=img
#plt.imshow(img)
"""
plt.plot(250,96, '.')
plt.plot(256,134, '.')
plt.plot(156,105, '.')
plt.plot(157,64, '.')
plt.show()
"""
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import numpy as np
import cv2
# Read in an image, you can also try test1.jpg or test4.jpg
fname = 'test6.jpg'
img = cv2.imread(fname)
img=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
import numpy as np
import cv2
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
def mag_thresh(img, sobel_kernel=3, thresh=(0, 255)):
# Convert image to grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Take the gradient in x and y separately
sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=sobel_kernel)
sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=sobel_kernel)
# Calculate the magnitude of the gradient
gradmag = np.sqrt(sobelx**2 + sobely**2)
# Scale to 8-bit (0-255) then convert to type = np.uint8
scaled_gradmag = np.uint8(255*gradmag/np.max(gradmag))
# Create a mask of 1's where the scaled gradient magnitude is within the given thresholds
mag_binary = np.zeros_like(scaled_gradmag)
mag_binary[(scaled_gradmag >= thresh[0]) & (scaled_gradmag <= thresh[1])] = 1
# Return binary output image
return mag_binary
def dir_thresh(img, sobel_kernel=3, thresh=(0, np.pi/2)):
# Convert image to grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Take the gradient in x and y separately
sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=sobel_kernel)
sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=sobel_kernel)
# Use np.arctan2(abs_sobely, abs_sobelx) to calculate direction of gradient
absgraddir = np.arctan2(np.absolute(sobely), np.absolute(sobelx))
# Create a mask of 1's where the gradient direction is within the given thresholds
dir_binary = np.zeros_like(absgraddir)
dir_binary[(absgraddir >= thresh[0]) & (absgraddir <= thresh[1])] = 1
# Return binary output image
return dir_binary
def color_thresh(img, r_thresh=(0, 255), s_thresh=(0, 255)):
# Apply a threshold to the R channel
r_channel = img[:,:,2]
r_binary = np.zeros_like(img[:,:,0])
# Create a mask of 1's where pixel value is within the given thresholds
r_binary[(r_channel > r_thresh[0]) & (r_channel <= r_thresh[1])] = 1
# Convert to HLS color space
hls = cv2.cvtColor(img, cv2.COLOR_BGR2HLS)
# Apply a threshold to the S channel
s_channel = hls[:,:,2]
s_binary = np.zeros_like(s_channel)
# Create a mask of 1's where pixel value is within the given thresholds
s_binary[(s_channel > s_thresh[0]) & (s_channel <= s_thresh[1])] = 1
# Combine two channels
combined = np.zeros_like(img[:,:,0])
combined[(s_binary == 1) | (r_binary == 1)] = 1
# Return binary output image
return combined
#image = mpimg.imread('test6.jpg')
# Edit this function to create your own pipeline.
def pipeline(img, s_thresh=(170, 255), sx_thresh=(20, 100)):
img = np.copy(img)
# Convert to HLS color space and separate the V channel
hls = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)
l_channel = hls[:,:,1]
s_channel = hls[:,:,2]
# Sobel x
sobelx = cv2.Sobel(l_channel, cv2.CV_64F, 1, 0) # Take the derivative in x
abs_sobelx = np.absolute(sobelx) # Absolute x derivative to accentuate lines away from horizontal
scaled_sobel = np.uint8(255*abs_sobelx/np.max(abs_sobelx))
# Threshold x gradient
sxbinary = np.zeros_like(scaled_sobel)
sxbinary[(scaled_sobel >= sx_thresh[0]) & (scaled_sobel <= sx_thresh[1])] = 1
# Threshold color channel
s_binary = np.zeros_like(s_channel)
s_binary[(s_channel >= s_thresh[0]) & (s_channel <= s_thresh[1])] = 1
# Stack each channel
color_binary = np.dstack(( np.zeros_like(sxbinary), sxbinary, s_binary)) * 255
return color_binary
# Threshold gradient
grad_binary = np.zeros_like(img[:,:,0])
mag_binary = mag_thresh(img, sobel_kernel=9, thresh=(50, 255))
dir_binary = dir_thresh(img, sobel_kernel=15, thresh=(0.7, 1.3))
grad_binary[((mag_binary == 1) & (dir_binary == 1))] = 1
# Threshold color
color_binary = color_thresh(img, r_thresh=(220, 255), s_thresh=(150, 255))
# Combine gradient and color thresholds
combo_binary = np.zeros_like(img[:,:,0])
combo_binary[(grad_binary == 1) | (color_binary == 1)] = 255
result=combo_binary
plt.imshow(result)
plt.show()
#result = pipeline(img)
# Plot the result
f, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 9))
f.tight_layout()
ax1.imshow(img)
ax1.set_title('Original Image', fontsize=40)
ax2.imshow(result)
ax2.set_title('Pipeline Result', fontsize=40)
plt.subplots_adjust(left=0., right=1, top=0.9, bottom=0.)
plt.show()
"""
# Define a function that thresholds the S-channel of HLS
# Use exclusive lower bound (>) and inclusive upper (<=)
def hls_select(img, thresh=(0, 255)):
hls = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)
s_channel = hls[:,:,2]
binary_output = np.zeros_like(s_channel)
binary_output[(s_channel > thresh[0]) & (s_channel <= thresh[1])] = 1
return binary_output
hls_binary = hls_select(img, thresh=(90, 255))
# Plot the result
f, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 9))
f.tight_layout()
ax1.imshow(img)
ax1.set_title('Original Image', fontsize=50)
ax2.imshow(hls_binary, cmap='gray')
ax2.set_title('Thresholded S', fontsize=50)
plt.subplots_adjust(left=0., right=1, top=0.9, bottom=0.)
plt.show()
"""
def warp(img):
src=np.float32(
[[575,483],
[771,483],
[1092,680],
[296,680]])
dst=np.float32(
[[200,300],
[1100,300],
[1100,700],
[200,700]])
img_size=(img.shape[1], img.shape[0])
M = cv2.getPerspectiveTransform(src, dst)
Minv = cv2.getPerspectiveTransform(dst, src)
warped = cv2.warpPerspective(img, M, img_size, flags=cv2.INTER_LINEAR)
return warped
warped_im=warp(result)
#f,(ax1,ax2)=plt.subplots(1,2,figsize=(20,10))
plt.imshow(warped_im)
plt.show()
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import glob
import cv2
#warped_im = cv2.cvtColor(warped_im, cv2.COLOR_RGB2GRAY)
# Read in a thresholded image
warped = warped_im
#warped=cv2.cvtColor(warped,cv2.COLOR_BGR2GRAY)
# window settings
binary_warped=warped
# Assuming you have created a warped binary image called "binary_warped"
# Take a histogram of the bottom half of the image
histogram = np.sum(binary_warped[binary_warped.shape[0]//2:,:], axis=0)
# Create an output image to draw on and visualize the result
out_img = np.dstack((binary_warped, binary_warped, binary_warped))*255
# Find the peak of the left and right halves of the histogram
# These will be the starting point for the left and right lines
midpoint = np.int(histogram.shape[0]//2)
leftx_base = np.argmax(histogram[:midpoint])
rightx_base = np.argmax(histogram[midpoint:]) + midpoint
# Choose the number of sliding windows
nwindows = 9
# Set height of windows
window_height = np.int(binary_warped.shape[0]//nwindows)
# Identify the x and y positions of all nonzero pixels in the image
nonzero = binary_warped.nonzero()
nonzeroy = np.array(nonzero[0])
nonzerox = np.array(nonzero[1])
# Current positions to be updated for each window
leftx_current = leftx_base
rightx_current = rightx_base
# Set the width of the windows +/- margin
margin = 100
# Set minimum number of pixels found to recenter window
minpix = 50
# Create empty lists to receive left and right lane pixel indices
left_lane_inds = []
right_lane_inds = []
# Step through the windows one by one
for window in range(nwindows):
# Identify window boundaries in x and y (and right and left)
win_y_low = binary_warped.shape[0] - (window+1)*window_height
win_y_high = binary_warped.shape[0] - window*window_height
win_xleft_low = leftx_current - margin
win_xleft_high = leftx_current + margin
win_xright_low = rightx_current - margin
win_xright_high = rightx_current + margin
# Draw the windows on the visualization image
cv2.rectangle(out_img,(win_xleft_low,win_y_low),(win_xleft_high,win_y_high),
(0,255,0), 2)
cv2.rectangle(out_img,(win_xright_low,win_y_low),(win_xright_high,win_y_high),
(0,255,0), 2)
# Identify the nonzero pixels in x and y within the window
good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) &
(nonzerox >= win_xleft_low) & (nonzerox < win_xleft_high)).nonzero()[0]
good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) &
(nonzerox >= win_xright_low) & (nonzerox < win_xright_high)).nonzero()[0]
# Append these indices to the lists
left_lane_inds.append(good_left_inds)
right_lane_inds.append(good_right_inds)
# If you found > minpix pixels, recenter next window on their mean position
if len(good_left_inds) > minpix:
leftx_current = np.int(np.mean(nonzerox[good_left_inds]))
if len(good_right_inds) > minpix:
rightx_current = np.int(np.mean(nonzerox[good_right_inds]))
# Concatenate the arrays of indices
left_lane_inds = np.concatenate(left_lane_inds)
right_lane_inds = np.concatenate(right_lane_inds)
# Extract left and right line pixel positions
leftx = nonzerox[left_lane_inds]
lefty = nonzeroy[left_lane_inds]
rightx = nonzerox[right_lane_inds]
righty = nonzeroy[right_lane_inds]
# Fit a second order polynomial to each
left_fit = np.polyfit(lefty, leftx, 2)
right_fit = np.polyfit(righty, rightx, 2)
#Visualization
# Generate x and y values for plotting
ploty = np.linspace(0, binary_warped.shape[0]-1, binary_warped.shape[0] )
left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]
right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]
out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0]
out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [0, 0, 255]
plt.imshow(out_img)
plt.plot(left_fitx, ploty, color='yellow')
plt.plot(right_fitx, ploty, color='yellow')
plt.xlim(0, 1280)
plt.ylim(720, 0)
plt.show()
output=out_img
"""
window_width = 50
window_height = 80 # Break image into 9 vertical layers since image height is 720
margin = 10 # How much to slide left and right for searching
def window_mask(width, height, img_ref, center,level):
output = np.zeros_like(img_ref)
output[int(img_ref.shape[0]-(level+1)*height):int(img_ref.shape[0]-level*height),max(0,int(center-width/2)):min(int(center+width/2),img_ref.shape[1])] = 1
return output
def find_window_centroids(image, window_width, window_height, margin):
window_centroids = [] # Store the (left,right) window centroid positions per level
window = np.ones(window_width) # Create our window template that we will use for convolutions
# First find the two starting positions for the left and right lane by using np.sum to get the vertical image slice
# and then np.convolve the vertical image slice with the window template
# Sum quarter bottom of image to get slice, could use a different ratio
l_sum = np.sum(image[int(3*image.shape[0]/4):,:int(image.shape[1]/2)], axis=0)
l_center = np.argmax(np.convolve(window,l_sum))-window_width/2
r_sum = np.sum(image[int(3*image.shape[0]/4):,int(image.shape[1]/2):], axis=0)
r_center = np.argmax(np.convolve(window,r_sum))-window_width/2+int(image.shape[1]/2)
# Add what we found for the first layer
window_centroids.append((l_center,r_center))
# Go through each layer looking for max pixel locations
for level in range(1,(int)(image.shape[0]/window_height)):
# convolve the window into the vertical slice of the image
image_layer = np.sum(image[int(image.shape[0]-(level+1)*window_height):int(image.shape[0]-level*window_height),:], axis=0)
conv_signal = np.convolve(window, image_layer)
# Find the best left centroid by using past left center as a reference
# Use window_width/2 as offset because convolution signal reference is at right side of window, not center of window
offset = window_width/2
l_min_index = int(max(l_center+offset-margin,0))
l_max_index = int(min(l_center+offset+margin,image.shape[1]))
l_center = np.argmax(conv_signal[l_min_index:l_max_index])+l_min_index-offset
# Find the best right centroid by using past right center as a reference
r_min_index = int(max(r_center+offset-margin,0))
r_max_index = int(min(r_center+offset+margin,image.shape[1]))
r_center = np.argmax(conv_signal[r_min_index:r_max_index])+r_min_index-offset
# Add what we found for that layer
window_centroids.append((l_center,r_center))
return window_centroids
window_centroids = find_window_centroids(warped, window_width, window_height, margin)
# If we found any window centers
if len(window_centroids) > 0:
# Points used to draw all the left and right windows
l_points = np.zeros_like(warped)
r_points = np.zeros_like(warped)
# Go through each level and draw the windows
for level in range(0,len(window_centroids)):
# Window_mask is a function to draw window areas
l_mask = window_mask(window_width,window_height,warped,window_centroids[level][0],level)
r_mask = window_mask(window_width,window_height,warped,window_centroids[level][1],level)
# Add graphic points from window mask here to total pixels found
l_points[(l_points == 255) | ((l_mask == 1) ) ] = 255
r_points[(r_points == 255) | ((r_mask == 1) ) ] = 255
# Draw the results
template = np.array(r_points+l_points,np.uint8) # add both left and right window pixels together
zero_channel = np.zeros_like(template) # create a zero color channel
template = np.array(cv2.merge((zero_channel,template,zero_channel)),np.uint8) # make window pixels green
warpage= np.dstack((warped, warped, warped))*255 # making the original road pixels 3 color channels
output = cv2.addWeighted(warpage, 1, template, 0.5, 0.0) # overlay the orignal road image with window results
output=template
# If no window centers found, just display orginal road image
else:
output = np.array(cv2.merge((warped,warped,warped)),np.uint8)
"""
# Display the final results
plt.imshow(output)
plt.title('window fitting results')
plt.show()
def warp_back(img):
src=np.float32(
[[575,483],
[771,483],
[1092,680],
[296,680]])
dst=np.float32(
[[200,300],
[1100,300],
[1100,700],
[200,700]])
img_size=(img.shape[1], img.shape[0])
M = cv2.getPerspectiveTransform(src, dst)
Minv = cv2.getPerspectiveTransform(dst, src)
warped_back = cv2.warpPerspective(img, Minv, img_size, flags=cv2.INTER_LINEAR)
return warped_back
output=warp_back(output)
output = cv2.addWeighted(orignal_img, 1, output, 0.5, 0.5)
plt.imshow(output)
plt.show()
#next pic
# Assume you now have a new warped binary image
# from the next frame of video (also called "binary_warped")
# It's now much easier to find line pixels!
nonzero = binary_warped.nonzero()
nonzeroy = np.array(nonzero[0])
nonzerox = np.array(nonzero[1])
margin = 18
left_lane_inds = ((nonzerox > (left_fit[0]*(nonzeroy**2) + left_fit[1]*nonzeroy +
left_fit[2] - margin)) & (nonzerox < (left_fit[0]*(nonzeroy**2) +
left_fit[1]*nonzeroy + left_fit[2] + margin)))
right_lane_inds = ((nonzerox > (right_fit[0]*(nonzeroy**2) + right_fit[1]*nonzeroy +
right_fit[2] - margin)) & (nonzerox < (right_fit[0]*(nonzeroy**2) +
right_fit[1]*nonzeroy + right_fit[2] + margin)))
# Again, extract left and right line pixel positions
leftx = nonzerox[left_lane_inds]
lefty = nonzeroy[left_lane_inds]
rightx = nonzerox[right_lane_inds]
righty = nonzeroy[right_lane_inds]
# Fit a second order polynomial to each
left_fit = np.polyfit(lefty, leftx, 2)
right_fit = np.polyfit(righty, rightx, 2)
# Generate x and y values for plotting
ploty = np.linspace(0, binary_warped.shape[0]-1, binary_warped.shape[0] )
left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]
right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]
# Create an image to draw on and an image to show the selection window
out_img = np.dstack((binary_warped, binary_warped, binary_warped))*255
window_img = np.zeros_like(out_img)
# Color in left and right line pixels
out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0]
out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [0, 0, 255]
# Generate a polygon to illustrate the search window area
# And recast the x and y points into usable format for cv2.fillPoly()
left_line_window1 = np.array([np.transpose(np.vstack([left_fitx-margin, ploty]))])
left_line_window2 = np.array([np.flipud(np.transpose(np.vstack([left_fitx+margin,
ploty])))])
left_line_pts = np.hstack((left_line_window1, left_line_window2))
right_line_window1 = np.array([np.transpose(np.vstack([right_fitx-margin, ploty]))])
right_line_window2 = np.array([np.flipud(np.transpose(np.vstack([right_fitx+margin,
ploty])))])
right_line_pts = np.hstack((right_line_window1, right_line_window2))
# Draw the lane onto the warped blank image
cv2.fillPoly(window_img, np.int_([left_line_pts]), (0,255, 0))
cv2.fillPoly(window_img, np.int_([right_line_pts]), (0,255, 0))
result = cv2.addWeighted(out_img, 1, window_img, 0.3, 0)
plt.imshow(result)
#plt.show()
plt.plot(left_fitx, ploty, color='yellow')
plt.plot(right_fitx, ploty, color='yellow')
plt.xlim(0, 1280)
plt.ylim(720, 0)
plt.show()
output=window_img
output=warp_back(output)
output = cv2.addWeighted(orignal_img, 1, output, 0.5, 0.5)
plt.imshow(output)
plt.show()
src=np.float32(
[[575,483],
[771,483],
[1092,680],
[296,680]])
dst=np.float32(
[[200,300],
[1100,300],
[1100,700],
[200,700]])
#img_size=(img.shape[1], img.shape[0])
#M = cv2.getPerspectiveTransform(src, dst)
Minv = cv2.getPerspectiveTransform(dst, src)
# Create an image to draw the lines on
warp_zero = np.zeros_like(output).astype(np.uint8)
color_warp = warp_zero
# Recast the x and y points into usable format for cv2.fillPoly()
pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])
pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])
pts = np.hstack((pts_left, pts_right))
# Draw the lane onto the warped blank image
cv2.fillPoly(color_warp, np.int_([pts]), (0,255, 0))
# Warp the blank back to original image space using inverse perspective matrix (Minv)
newwarp = cv2.warpPerspective(color_warp, Minv, (output.shape[1], output.shape[0]))
# Combine the result with the original image
result = cv2.addWeighted(output, 1, newwarp, 0.3, 0)
plt.imshow(result)
plt.show()
y_eval = np.max(ploty)
left_curverad = ((1 + (2*left_fit[0]*y_eval + left_fit[1])**2)**1.5) / np.absolute(2*left_fit[0])
right_curverad = ((1 + (2*right_fit[0]*y_eval + right_fit[1])**2)**1.5) / np.absolute(2*right_fit[0])
print(left_curverad, right_curverad)
# Example values: 1926.74 1908.48
# Define conversions in x and y from pixels space to meters
ym_per_pix = 30/720 # meters per pixel in y dimension
xm_per_pix = 3.7/900 # meters per pixel in x dimension
# Fit new polynomials to x,y in world space
left_fit_cr = np.polyfit(ploty*ym_per_pix, left_fitx*xm_per_pix, 2)
right_fit_cr = np.polyfit(ploty*ym_per_pix, right_fitx*xm_per_pix, 2)
# Calculate the new radii of curvature
left_curverad = ((1 + (2*left_fit_cr[0]*y_eval*ym_per_pix + left_fit_cr[1])**2)**1.5) / np.absolute(2*left_fit_cr[0])
right_curverad = ((1 + (2*right_fit_cr[0]*y_eval*ym_per_pix + right_fit_cr[1])**2)**1.5) / np.absolute(2*right_fit_cr[0])
# Now our radius of curvature is in meters
# Calculate vehicle center
xMax = output.shape[1]*xm_per_pix
yMax = output.shape[0]*ym_per_pix
car_centre = xMax / 2
Left_line = left_fit_cr[0]*yMax**2 + left_fit_cr[1]*yMax + left_fit_cr[2]
Right_line = right_fit_cr[0]*yMax**2 + right_fit_cr[1]*yMax + right_fit_cr[2]
Middle_line = Left_line + (Right_line - Left_line)/2
meter_from_middle = Middle_line - car_centre
if meter_from_middle<0:
meter_from_middle=-meter_from_middle
font = cv2.FONT_HERSHEY_SIMPLEX
fontColor = (0, 0, 0)
cv2.putText(result, 'Left curvature: {:.2f} m'.format(left_curverad), (600, 50), font, 1, fontColor, 2)
cv2.putText(result, 'Right curvature: {:.2f} m'.format(right_curverad), (600, 80), font, 1, fontColor, 2)
cv2.putText(result, 'from center: {:.2f} m'.format(meter_from_middle), (600, 110), font, 1, fontColor, 2)
plt.imshow(result)
plt.show()
print(meter_from_middle)
print(left_curverad, 'm', right_curverad, 'm')
# Example values: 632.1 m 626.2 m
In [3]:
import numpy as np
import cv2
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from moviepy.editor import VideoFileClip
from IPython.display import HTML
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import glob
import cv2
video_name='project_video'
#video_name='solidYellowLeft'
#video_name='challenge'
clip = VideoFileClip(video_name+'.mp4')
white_output = video_name+'_result.mp4'
# Edit this function to create your own pipeline.
def pipeline(img, s_thresh=(170, 255), sx_thresh=(20, 100)):
img = np.copy(img)
# Convert to HLS color space and separate the V channel
hls = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)
l_channel = hls[:,:,1]
s_channel = hls[:,:,2]
# Sobel x
sobelx = cv2.Sobel(l_channel, cv2.CV_64F, 1, 0) # Take the derivative in x
abs_sobelx = np.absolute(sobelx) # Absolute x derivative to accentuate lines away from horizontal
scaled_sobel = np.uint8(255*abs_sobelx/np.max(abs_sobelx))
# Threshold x gradient
sxbinary = np.zeros_like(scaled_sobel)
sxbinary[(scaled_sobel >= sx_thresh[0]) & (scaled_sobel <= sx_thresh[1])] = 1
# Threshold color channel
s_binary = np.zeros_like(s_channel)
s_binary[(s_channel >= s_thresh[0]) & (s_channel <= s_thresh[1])] = 1
# Stack each channel
color_binary = np.dstack(( np.zeros_like(sxbinary), sxbinary, s_binary)) * 255
return color_binary
def mag_thresh(img, sobel_kernel=3, thresh=(0, 255)):
# Convert image to grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Take the gradient in x and y separately
sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=sobel_kernel)
sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=sobel_kernel)
# Calculate the magnitude of the gradient
gradmag = np.sqrt(sobelx**2 + sobely**2)
# Scale to 8-bit (0-255) then convert to type = np.uint8
scaled_gradmag = np.uint8(255*gradmag/np.max(gradmag))
# Create a mask of 1's where the scaled gradient magnitude is within the given thresholds
mag_binary = np.zeros_like(scaled_gradmag)
mag_binary[(scaled_gradmag >= thresh[0]) & (scaled_gradmag <= thresh[1])] = 1
# Return binary output image
return mag_binary
def dir_thresh(img, sobel_kernel=3, thresh=(0, np.pi/2)):
# Convert image to grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Take the gradient in x and y separately
sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=sobel_kernel)
sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=sobel_kernel)
# Use np.arctan2(abs_sobely, abs_sobelx) to calculate direction of gradient
absgraddir = np.arctan2(np.absolute(sobely), np.absolute(sobelx))
# Create a mask of 1's where the gradient direction is within the given thresholds
dir_binary = np.zeros_like(absgraddir)
dir_binary[(absgraddir >= thresh[0]) & (absgraddir <= thresh[1])] = 1
# Return binary output image
return dir_binary
def color_thresh(img, r_thresh=(0, 255), s_thresh=(0, 255)):
# Apply a threshold to the R channel
r_channel = img[:,:,2]
r_binary = np.zeros_like(img[:,:,0])
# Create a mask of 1's where pixel value is within the given thresholds
r_binary[(r_channel > r_thresh[0]) & (r_channel <= r_thresh[1])] = 1
# Convert to HLS color space
hls = cv2.cvtColor(img, cv2.COLOR_BGR2HLS)
# Apply a threshold to the S channel
s_channel = hls[:,:,2]
s_binary = np.zeros_like(s_channel)
# Create a mask of 1's where pixel value is within the given thresholds
s_binary[(s_channel > s_thresh[0]) & (s_channel <= s_thresh[1])] = 1
# Combine two channels
combined = np.zeros_like(img[:,:,0])
combined[(s_binary == 1) | (r_binary == 1)] = 1
# Return binary output image
return combined
def warp(img):
src=np.float32(
[[575,483],
[771,483],
[1092,680],
[296,680]])
dst=np.float32(
[[200,300],
[1100,300],
[1100,700],
[200,700]])
img_size=(img.shape[1], img.shape[0])
M = cv2.getPerspectiveTransform(src, dst)
Minv = cv2.getPerspectiveTransform(dst, src)
warped = cv2.warpPerspective(img, M, img_size, flags=cv2.INTER_LINEAR)
return warped
def warp_back(img):
src=np.float32(
[[575,483],
[771,483],
[1092,680],
[296,680]])
dst=np.float32(
[[200,300],
[1100,300],
[1100,700],
[200,700]])
img_size=(img.shape[1], img.shape[0])
M = cv2.getPerspectiveTransform(src, dst)
Minv = cv2.getPerspectiveTransform(dst, src)
warped_back = cv2.warpPerspective(img, Minv, img_size, flags=cv2.INTER_LINEAR)
return warped_back
num_counted=0
def process_image(image):
global num_counted
#print(num_counted)
i=2
image_name='calibration'+str(i)
existing_folder_name='camera_cal/'
New_foler_name='output_images/'
fname = existing_folder_name+image_name+".jpg"
img = cv2.imread(fname)
objpoints=[]
imgpoints=[]
objp=np.zeros((6*9,3), np.float32)
objp[:,:2]=np.mgrid[0:9,0:6].T.reshape(-1,2)
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ret, corners = cv2.findChessboardCorners(gray,(9,6),None)
#if ret == True:
imgpoints.append(corners)
objpoints.append(objp)
img=cv2.drawChessboardCorners(img, (9, 6), corners, ret)
ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None)
dst = cv2.undistort(img, mtx, dist, None, mtx)
#plt.imshow(dst)
#plt.show()
#cv2.imwrite(New_foler_name+image_name+"_result.jpg", dst)
img = np.copy(image)
img=cv2.undistort(img, mtx, dist, None, mtx)
#plt.imshow(img)
#plt.show()
orignal_img=img
#plt.imshow(img)
# Read in an image, you can also try test1.jpg or test4.jpg
#fname = 'test6.jpg'
#img = cv2.imread(fname)
#img=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
#image = mpimg.imread('test6.jpg')
# Threshold gradient
grad_binary = np.zeros_like(img[:,:,0])
mag_binary = mag_thresh(img, sobel_kernel=9, thresh=(50, 255))
dir_binary = dir_thresh(img, sobel_kernel=15, thresh=(0.7, 1.3))
grad_binary[((mag_binary == 1) & (dir_binary == 1))] = 1
# Threshold color
color_binary = color_thresh(img, r_thresh=(220, 255), s_thresh=(150, 255))
# Combine gradient and color thresholds
combo_binary = np.zeros_like(img[:,:,0])
combo_binary[(grad_binary == 1) | (color_binary == 1)] = 255
result=combo_binary
#result = pipeline(img)
# Plot the result
f, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 9))
f.tight_layout()
ax1.imshow(img)
ax1.set_title('Original Image', fontsize=40)
ax2.imshow(result)
ax2.set_title('Pipeline Result', fontsize=40)
#plt.subplots_adjust(left=0., right=1, top=0.9, bottom=0.)
#plt.show()
"""
# Define a function that thresholds the S-channel of HLS
# Use exclusive lower bound (>) and inclusive upper (<=)
def hls_select(img, thresh=(0, 255)):
hls = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)
s_channel = hls[:,:,2]
binary_output = np.zeros_like(s_channel)
binary_output[(s_channel > thresh[0]) & (s_channel <= thresh[1])] = 1
return binary_output
hls_binary = hls_select(img, thresh=(90, 255))
# Plot the result
f, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 9))
f.tight_layout()
ax1.imshow(img)
ax1.set_title('Original Image', fontsize=50)
ax2.imshow(hls_binary, cmap='gray')
ax2.set_title('Thresholded S', fontsize=50)
plt.subplots_adjust(left=0., right=1, top=0.9, bottom=0.)
plt.show()
"""
warped_im=warp(result)
#f,(ax1,ax2)=plt.subplots(1,2,figsize=(20,10))
#plt.imshow(warped_im)
#plt.show()
#warped_im = cv2.cvtColor(warped_im, cv2.COLOR_RGB2GRAY)
# Read in a thresholded image
warped = warped_im
#warped=cv2.cvtColor(warped,cv2.COLOR_BGR2GRAY)
# window settings
binary_warped=warped
global left_fit
global right_fit
if num_counted==0:
histogram = np.sum(binary_warped[binary_warped.shape[0]//2:,:], axis=0)
# Create an output image to draw on and visualize the result
out_img = np.dstack((binary_warped, binary_warped, binary_warped))*255
# Find the peak of the left and right halves of the histogram
# These will be the starting point for the left and right lines
midpoint = np.int(histogram.shape[0]//2)
leftx_base = np.argmax(histogram[:midpoint])
rightx_base = np.argmax(histogram[midpoint:]) + midpoint
# Choose the number of sliding windows
nwindows = 9
# Set height of windows
window_height = np.int(binary_warped.shape[0]//nwindows)
# Identify the x and y positions of all nonzero pixels in the image
nonzero = binary_warped.nonzero()
nonzeroy = np.array(nonzero[0])
nonzerox = np.array(nonzero[1])
# Current positions to be updated for each window
leftx_current = leftx_base
rightx_current = rightx_base
# Set the width of the windows +/- margin
margin = 100
# Set minimum number of pixels found to recenter window
minpix = 50
# Create empty lists to receive left and right lane pixel indices
left_lane_inds = []
right_lane_inds = []
# Step through the windows one by one
for window in range(nwindows):
# Identify window boundaries in x and y (and right and left)
win_y_low = binary_warped.shape[0] - (window+1)*window_height
win_y_high = binary_warped.shape[0] - window*window_height
win_xleft_low = leftx_current - margin
win_xleft_high = leftx_current + margin
win_xright_low = rightx_current - margin
win_xright_high = rightx_current + margin
# Draw the windows on the visualization image
cv2.rectangle(out_img,(win_xleft_low,win_y_low),(win_xleft_high,win_y_high),
(0,255,0), 2)
cv2.rectangle(out_img,(win_xright_low,win_y_low),(win_xright_high,win_y_high),
(0,255,0), 2)
# Identify the nonzero pixels in x and y within the window
good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) &
(nonzerox >= win_xleft_low) & (nonzerox < win_xleft_high)).nonzero()[0]
good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) &
(nonzerox >= win_xright_low) & (nonzerox < win_xright_high)).nonzero()[0]
# Append these indices to the lists
left_lane_inds.append(good_left_inds)
right_lane_inds.append(good_right_inds)
# If you found > minpix pixels, recenter next window on their mean position
if len(good_left_inds) > minpix:
leftx_current = np.int(np.mean(nonzerox[good_left_inds]))
if len(good_right_inds) > minpix:
rightx_current = np.int(np.mean(nonzerox[good_right_inds]))
# Concatenate the arrays of indices
left_lane_inds = np.concatenate(left_lane_inds)
right_lane_inds = np.concatenate(right_lane_inds)
# Extract left and right line pixel positions
leftx = nonzerox[left_lane_inds]
lefty = nonzeroy[left_lane_inds]
rightx = nonzerox[right_lane_inds]
righty = nonzeroy[right_lane_inds]
# Fit a second order polynomial to each
left_fit = np.polyfit(lefty, leftx, 2)
right_fit = np.polyfit(righty, rightx, 2)
#Visualization
# Generate x and y values for plotting
ploty = np.linspace(0, binary_warped.shape[0]-1, binary_warped.shape[0] )
left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]
right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]
out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0]
out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [0, 0, 255]
#plt.imshow(out_img)
#plt.plot(left_fitx, ploty, color='yellow')
#plt.plot(right_fitx, ploty, color='yellow')
#plt.xlim(0, 1280)
#plt.ylim(720, 0)
#plt.show()
output=out_img
# Display the final results
#plt.imshow(output)
#plt.title('window fitting results')
#plt.show()
output=warp_back(output)
output = cv2.addWeighted(orignal_img, 1, output, 0.5, 0.5)
#plt.imshow(output)
#plt.show()
else:
#next pic
# Assume you now have a new warped binary image
# from the next frame of video (also called "binary_warped")
# It's now much easier to find line pixels!
nonzero = binary_warped.nonzero()
nonzeroy = np.array(nonzero[0])
nonzerox = np.array(nonzero[1])
margin = 18
left_lane_inds = ((nonzerox > (left_fit[0]*(nonzeroy**2) + left_fit[1]*nonzeroy +
left_fit[2] - margin)) & (nonzerox < (left_fit[0]*(nonzeroy**2) +
left_fit[1]*nonzeroy + left_fit[2] + margin)))
right_lane_inds = ((nonzerox > (right_fit[0]*(nonzeroy**2) + right_fit[1]*nonzeroy +
right_fit[2] - margin)) & (nonzerox < (right_fit[0]*(nonzeroy**2) +
right_fit[1]*nonzeroy + right_fit[2] + margin)))
# Again, extract left and right line pixel positions
leftx = nonzerox[left_lane_inds]
lefty = nonzeroy[left_lane_inds]
rightx = nonzerox[right_lane_inds]
righty = nonzeroy[right_lane_inds]
# Fit a second order polynomial to each
left_fit = np.polyfit(lefty, leftx, 2)
right_fit = np.polyfit(righty, rightx, 2)
# Generate x and y values for plotting
ploty = np.linspace(0, binary_warped.shape[0]-1, binary_warped.shape[0] )
left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]
right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]
# Create an image to draw on and an image to show the selection window
out_img = np.dstack((binary_warped, binary_warped, binary_warped))*255
window_img = np.zeros_like(out_img)
# Color in left and right line pixels
out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0]
out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [0, 0, 255]
# Generate a polygon to illustrate the search window area
# And recast the x and y points into usable format for cv2.fillPoly()
left_line_window1 = np.array([np.transpose(np.vstack([left_fitx-margin, ploty]))])
left_line_window2 = np.array([np.flipud(np.transpose(np.vstack([left_fitx+margin,
ploty])))])
left_line_pts = np.hstack((left_line_window1, left_line_window2))
right_line_window1 = np.array([np.transpose(np.vstack([right_fitx-margin, ploty]))])
right_line_window2 = np.array([np.flipud(np.transpose(np.vstack([right_fitx+margin,
ploty])))])
right_line_pts = np.hstack((right_line_window1, right_line_window2))
# Draw the lane onto the warped blank image
cv2.fillPoly(window_img, np.int_([left_line_pts]), (0,255, 0))
cv2.fillPoly(window_img, np.int_([right_line_pts]), (0,255, 0))
result = cv2.addWeighted(out_img, 1, window_img, 0.3, 0)
#plt.imshow(result)
#plt.show()
#plt.plot(left_fitx, ploty, color='yellow')
#plt.plot(right_fitx, ploty, color='yellow')
#plt.xlim(0, 1280)
#plt.ylim(720, 0)
#plt.show()
output=window_img
output=warp_back(output)
output = cv2.addWeighted(orignal_img, 1, output, 0.5, 0.5)
src=np.float32(
[[575,483],
[771,483],
[1092,680],
[296,680]])
dst=np.float32(
[[200,300],
[1100,300],
[1100,700],
[200,700]])
#img_size=(img.shape[1], img.shape[0])
#M = cv2.getPerspectiveTransform(src, dst)
Minv = cv2.getPerspectiveTransform(dst, src)
# Create an image to draw the lines on
warp_zero = np.zeros_like(output).astype(np.uint8)
color_warp = warp_zero
# Recast the x and y points into usable format for cv2.fillPoly()
pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])
pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])
pts = np.hstack((pts_left, pts_right))
# Draw the lane onto the warped blank image
cv2.fillPoly(color_warp, np.int_([pts]), (0,255, 0))
# Warp the blank back to original image space using inverse perspective matrix (Minv)
newwarp = cv2.warpPerspective(color_warp, Minv, (output.shape[1], output.shape[0]))
# Combine the result with the original image
result = cv2.addWeighted(output, 1, newwarp, 0.3, 0)
#plt.imshow(result)
#plt.show()
y_eval = np.max(ploty)
left_curverad = ((1 + (2*left_fit[0]*y_eval + left_fit[1])**2)**1.5) / np.absolute(2*left_fit[0])
right_curverad = ((1 + (2*right_fit[0]*y_eval + right_fit[1])**2)**1.5) / np.absolute(2*right_fit[0])
#print(left_curverad, right_curverad)
# Example values: 1926.74 1908.48
# Define conversions in x and y from pixels space to meters
ym_per_pix = 30/720 # meters per pixel in y dimension
xm_per_pix = 3.7/900 # meters per pixel in x dimension
# Fit new polynomials to x,y in world space
left_fit_cr = np.polyfit(ploty*ym_per_pix, left_fitx*xm_per_pix, 2)
right_fit_cr = np.polyfit(ploty*ym_per_pix, right_fitx*xm_per_pix, 2)
# Calculate the new radii of curvature
left_curverad = ((1 + (2*left_fit_cr[0]*y_eval*ym_per_pix + left_fit_cr[1])**2)**1.5) / np.absolute(2*left_fit_cr[0])
right_curverad = ((1 + (2*right_fit_cr[0]*y_eval*ym_per_pix + right_fit_cr[1])**2)**1.5) / np.absolute(2*right_fit_cr[0])
# Now our radius of curvature is in meters
# Calculate vehicle center
xMax = output.shape[1]*xm_per_pix
yMax = output.shape[0]*ym_per_pix
car_centre = xMax / 2
Left_line = left_fit_cr[0]*yMax**2 + left_fit_cr[1]*yMax + left_fit_cr[2]
Right_line = right_fit_cr[0]*yMax**2 + right_fit_cr[1]*yMax + right_fit_cr[2]
Middle_line = Left_line + (Right_line - Left_line)/2
meter_from_middle = Middle_line - car_centre
if meter_from_middle<0:
meter_from_middle=-meter_from_middle
k='left side'
else:
k='right side'
font = cv2.FONT_HERSHEY_SIMPLEX
fontColor = (0, 0, 0)
cv2.putText(result, 'Left curvature: {:.2f} m'.format(left_curverad), (600, 50), font, 1, fontColor, 2)
cv2.putText(result, 'Right curvature: {:.2f} m'.format(right_curverad), (600, 80), font, 1, fontColor, 2)
cv2.putText(result, 'from center: {:.2f} m'.format(meter_from_middle), (600, 110), font, 1, fontColor, 2)
cv2.putText(result, k, (600, 140), font, 1, fontColor, 2)
#plt.imshow(result)
#plt.show()
num_counted=num_counted+1
# Now our radius of curvature is in meters
#print(left_curverad, 'm', right_curverad, 'm')
# Example values: 632.1 m 626.2 m
return result
#video
white_clip = clip.fl_image(process_image) #NOTE: this function expects color images!!
white_clip.write_videofile(white_output, audio=False)